home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / boot / netBoot.new / dev / si.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-19  |  14.4 KB  |  674 lines
  1.  
  2. #ifndef lint
  3. /* static    char sccsid[] = "@(#)si.c 1.1 86/09/27 Copyr 1986 Sun Micro"; */
  4. #endif
  5.  
  6. /*
  7.  * Copyright (c) 1986 by Sun Microsystems, Inc.
  8.  */
  9.  
  10. #ifdef SUN3
  11.  
  12. #include "../h/types.h"
  13. #include "../h/buf.h"
  14. #include "../dev/dklabel.h"
  15. #include "../dev/dkio.h"
  16. #include "../dev/screg.h"
  17. #include "../dev/sireg.h"
  18. #include "../dev/scsi.h"
  19. #include "../dev/saio.h"
  20. #include "../h/sunromvec.h"
  21. #include "../h/idprom.h"
  22.  
  23. /*
  24.  * Low-level routines common to all devices on the SCSI bus.
  25.  */
  26.  
  27. /*
  28.  * Interface to the routines in this module is via a second "sip"
  29.  * structure contained in the caller's local variables.
  30.  *
  31.  * This "sip" must be initialized with sip->si_boottab = sidriver
  32.  * and must then be devopen()ed before any I/O can be done.
  33.  *
  34.  * The device must be closed with devclose().
  35.  */
  36.  
  37.  
  38. /* how si addresses look to the si vme scsi dma hardware */
  39. #define    SI_VME_DMA_ADDR(x)    (((int)x)&0x000FFFFF)
  40.  
  41. /* how si addresses look to the sun3/50 scsi dma hardware */
  42. #define    SI_OB_DMA_ADDR(x)    (((int)x)&0x00FFFFFF)
  43. struct sidma {
  44.     struct udc_table    udct;    /* dma information for udc */
  45. };
  46.  
  47. /*
  48.  * The interfaces we export
  49.  */
  50. extern char *devalloc();
  51. extern char *resalloc();
  52. extern int nullsys();
  53. int siopen();
  54.  
  55. struct boottab sidriver =
  56.     {"sd",    nullsys,    nullsys,    siopen,        nullsys,
  57.         nullsys,    "",    0};
  58.  
  59.  
  60. #define SI_VME_BASE    0x200000
  61. #define SI_OB_BASE    0x140000
  62. #define SI_SIZE        0x4000
  63.  
  64. /*
  65.  * Probe for si host adaptor interface. 
  66.  * Return 1 if found one, 0 otherwise.
  67.  */
  68. int
  69. siprobe(sip)
  70.     register struct saioreq    *sip;
  71. {
  72.     register struct scsi_si_reg *sir;
  73.     struct idprom id;
  74.     register int base;
  75.     register int scsi_nstd;
  76.     register int ctlr;
  77.     enum MAPTYPES space;
  78.  
  79. #ifdef M25
  80.     /* determine type of si interface */
  81.     if ((idprom(IDFORM_1, &id) == IDFORM_1) && 
  82.         (id.id_machine == IDM_SUN3_M25)) {
  83.         return (1);
  84.     } else {
  85.         return (0);
  86.     }
  87. #else
  88.  
  89.     /* determine type of si interface */
  90.     if (idprom(IDFORM_1, &id) == IDFORM_1) {
  91.         base = SI_VME_BASE;
  92.         space = MAP_VME24A16D;
  93.         scsi_nstd = 2;
  94.     } else {
  95.         return (0);
  96.     }
  97.  
  98.     /* get base address of registers */
  99.     if (sip->si_ctlr < scsi_nstd) {
  100.         ctlr = base + (sip->si_ctlr * SI_SIZE);
  101.     } else {
  102.         return (0);
  103.     }
  104.  
  105.     /* now map it in */
  106.     if ((sir = (struct scsi_si_reg *)devalloc(space, ctlr, 
  107.         sizeof(struct scsi_si_reg))) == 0) {
  108.         return (0);
  109.     }
  110.     
  111.     /*
  112.      * SI vme scsi host adaptor occupies 2K bytes in the vme 
  113.      * address space. SC vme scsi host adaptor occupies 4K 
  114.      * bytes in the vme address space.
  115.      * peek past 2K bytes to determine which host adaptor is there.
  116.      */
  117.     if (peek((int)sir+0x800) == -1) {
  118.         return (1);
  119.     } else {
  120.         return (0);
  121.     }
  122. #endif M25
  123. }
  124.  
  125. /*
  126.  * Open the SCSI host adapter.
  127.  */
  128. int
  129. siopen(sip)
  130.     register struct saioreq    *sip;
  131. {
  132.     register struct scsi_si_reg *sir;
  133.     struct idprom id;
  134.     register int base;
  135.     register int scsi_nstd;
  136.     enum MAPTYPES space;
  137.  
  138.     /* determine type of si interface */
  139.     if (idprom(IDFORM_1, &id) == IDFORM_1) {
  140. #ifdef M25
  141.         if (id.id_machine == IDM_SUN3_M25) {
  142.             base = SI_OB_BASE;
  143.             space = MAP_OBIO;
  144.             scsi_nstd = 1;
  145.         } else {
  146.             return (-1);
  147.         }
  148. #else
  149.         base = SI_VME_BASE;
  150.         space = MAP_VME24A16D;
  151.         scsi_nstd = 2;
  152. #endif M25
  153.     } else {
  154.         return (-1);
  155.     }
  156.  
  157.     /* get base address of registers */
  158.     if (sip->si_ctlr < scsi_nstd) {
  159.         sip->si_ctlr = base + (sip->si_ctlr * SI_SIZE);
  160.     } else {
  161.         return (-1);
  162.     }
  163.  
  164.     /* now map it in */
  165.     sip->si_devaddr = devalloc(space, sip->si_ctlr, 
  166.         sizeof(struct scsi_si_reg));
  167.     if (sip->si_devaddr == 0) {
  168.         return (-1);
  169.     }
  170.  
  171.     /* allocate dma resources */
  172. #ifdef M25
  173.     sip->si_dmaaddr = resalloc(RES_DMAMEM, sizeof(struct sidma));
  174.     if (sip->si_dmaaddr == 0) {
  175.         return (-1);
  176.     }
  177. #else
  178.     sip->si_dmaaddr = 0;
  179. #endif M25
  180.  
  181.     /* reset registers */
  182.     sir = (struct scsi_si_reg *) sip->si_devaddr;
  183.     sir->csr = 0;
  184.     DELAY(10);
  185.     sir->csr = SI_CSR_SCSI_RES | SI_CSR_FIFO_RES;
  186.     sir->bcr = 0;
  187. #ifndef M25
  188.     sir->dma_addr = 0;
  189.     sir->dma_count = 0;
  190.     sir->iv_am = VME_SUPV_DATA_24;
  191. #endif
  192.     return (0);
  193. }
  194.  
  195.  
  196. /*
  197.  * Write a command to the SCSI bus.
  198.  *
  199.  * The supplied sip is the one opened by siopen().
  200.  * DMA is done based on sip->si_ma and sip->si_cc.
  201.  *
  202.  * Returns -1 for error, otherwise returns the residual count not DMAed
  203.  * (zero for success).
  204.  *
  205.  * FIXME, this must be accessed via a boottab vector,
  206.  * to allow host adap to switch.
  207.  * Must pass cdb, scb in sip somewhere...
  208.  */
  209. int
  210. sidoit(cdb, scb, sip)
  211.     struct scsi_cdb *cdb;
  212.     struct scsi_scb *scb;
  213.     register struct saioreq *sip;
  214. {
  215.     register struct scsi_si_reg *sir;
  216.     register char *cp;
  217.     register int i;
  218.     register int b;
  219.     register int ob;
  220.     u_char junk;
  221.  
  222.     /* get to scsi control logic registers */
  223.     sir = (struct scsi_si_reg *) sip->si_devaddr;
  224. #ifdef M25
  225.     ob = 1;
  226. #else
  227.     ob = 0;
  228. #endif
  229.  
  230.     i = 100000;
  231.     for(;;) {
  232.         if ((sir->sbc_rreg.cbsr & SBC_CBSR_BSY) == 0) {
  233.             break;
  234.         }
  235.         if (i-- <= 0) {
  236.             si_reset(sir, ob);
  237.             return (-1);
  238.         }
  239.     }
  240.  
  241.     /* select target */
  242.     sir->sbc_wreg.odr = (1 << sip->si_unit) | SI_HOST_ID;
  243.     sir->sbc_wreg.icr = SBC_ICR_DATA;
  244.     sir->sbc_wreg.icr |= SBC_ICR_SEL;
  245.  
  246.     /* wait for target to acknowledge our selection */
  247.     if (si_sbc_wait(&sir->sbc_rreg.cbsr, SBC_CBSR_BSY, 1) == 0) {
  248.         sir->sbc_wreg.icr = 0;
  249.         sir->sbc_wreg.odr = 0;
  250.         return (-1);
  251.     }
  252.     sir->sbc_wreg.icr = 0;
  253.  
  254.     /* do initial dma setup */
  255.     sir->bcr = 0;    /* also reset dma_count for vme */
  256.     if (sip->si_cc > 0) {
  257.         if ((cdb->cmd == SC_READ) || (cdb->cmd == SC_REQUEST_SENSE)) {
  258.             sir->csr &= ~SI_CSR_SEND;
  259.         } else {
  260.             sir->csr |= SI_CSR_SEND;
  261.         }
  262.         sir->csr &= ~SI_CSR_FIFO_RES;
  263.         sir->csr |= SI_CSR_FIFO_RES;
  264.         sir->bcr = sip->si_cc;
  265. #ifndef M25
  266.         sir->bcrh = 0;
  267. #endif
  268.     }
  269.  
  270.     /* put command onto scsi bus */
  271.     cp = (char *)cdb;
  272.     if (si_putbyte(sir, PHASE_COMMAND, cp, sizeof(struct scsi_cdb)) == 0) {
  273.         sc_error("put of cmd onto scsi bus failed");
  274.         goto failed;
  275.     }
  276.  
  277.     /* finish dma setup and wait for dma completion */
  278.     if (sip->si_cc > 0) {
  279. #ifdef M25
  280.             si_ob_dma_setup(sir, 
  281.             &(((struct sidma *)sip->si_dmaaddr)->udct), cdb->cmd,
  282.             sip->si_cc, sip->si_ma);
  283. #else
  284.         if ((int)sip->si_ma & 1) {
  285.             sc_error("dma begins on odd address");
  286.             goto failed;
  287.         } else if ((int)sip->si_ma & 2) {
  288.             sir->csr |= SI_CSR_BPCON;
  289.         } else {
  290.             sir->csr &= ~SI_CSR_BPCON;
  291.         }
  292.         sir->dma_addr = SI_VME_DMA_ADDR(sip->si_ma);
  293.         sir->dma_count = sip->si_cc;
  294. #endif M25
  295.  
  296.         /* setup sbc and start dma */
  297.         sir->sbc_wreg.mr |= SBC_MR_DMA;
  298.         if ((cdb->cmd == SC_READ) || (cdb->cmd == SC_REQUEST_SENSE)) {
  299.             sir->sbc_wreg.tcr = TCR_DATA_IN;
  300.             sir->sbc_wreg.ircv = 0;
  301.         } else {
  302.             sir->sbc_wreg.tcr = TCR_DATA_OUT;
  303.             sir->sbc_wreg.icr = SBC_ICR_DATA;
  304.             sir->sbc_wreg.send = 0;
  305.         }
  306. #ifndef M25
  307.         sir->csr |= SI_CSR_DMA_EN;
  308. #endif M25
  309.  
  310.         /* wait for dma completion */
  311.         if (si_wait(&sir->csr, 
  312.             SI_CSR_SBC_IP|SI_CSR_DMA_IP|SI_CSR_DMA_CONFLICT, 1)
  313.             == 0) {
  314.             sc_error("dma never completed");
  315.             if (ob == 0) {
  316.                 sir->csr &= ~SI_CSR_DMA_EN;
  317.             }
  318.             si_dma_cleanup(sir, ob);
  319.             goto failed;
  320.         }
  321. #ifndef M25
  322.         sir->csr &= ~SI_CSR_DMA_EN;
  323. #endif M25
  324.  
  325.         /* check reason for dma completion */
  326.         if (sir->csr & SI_CSR_SBC_IP) {
  327.             /* dma operation should end with a phase mismatch */
  328.             si_sbc_wait(&sir->sbc_rreg.bsr, SBC_BSR_PMTCH, 0);
  329.         } else {
  330.             if (sir->csr & SI_CSR_DMA_CONFLICT) {
  331.                 sc_error("invalid reg access during dma");
  332.             } else if (sir->csr & SI_CSR_DMA_BUS_ERR) {
  333.                 sc_error("bus error during dma");
  334.             } else {
  335. #ifdef M25
  336.                 sc_error("unknown dma failure");
  337. #else
  338.                 sc_error("dma overrun");
  339. #endif M25
  340.             }
  341.             si_dma_cleanup(sir, ob);
  342.             goto failed;
  343.         }
  344.  
  345.         /* handle special dma recv situations */
  346.         if ((cdb->cmd == SC_READ) || (cdb->cmd == SC_REQUEST_SENSE)) {
  347. #ifdef M25
  348.             sir->udc_raddr = UDC_ADR_COUNT;
  349.             if (si_wait(&sir->csr, SI_CSR_FIFO_EMPTY, 1) == 0) {
  350.                 sc_error("fifo never emptied");
  351.                 si_dma_cleanup(sir, ob);
  352.                 goto failed;
  353.             }
  354.             /* if odd byte recv, must grab last byte by hand */
  355.             if ((sip->si_cc - sir->bcr) & 1) {
  356.                 cp = sip->si_ma + (sip->si_cc - sir->bcr) - 1;
  357.                 *cp = (sir->fifo_data & 0xff00) >> 8;
  358.  
  359.             /* udc may not dma last word */
  360.             } else if (((sir->udc_rdata*2) - sir->bcr) == 2) {
  361.                 cp = sip->si_ma + (sip->si_cc - sir->bcr);
  362.                 *(cp - 2) = (sir->fifo_data & 0xff00) >> 8;
  363.                 *(cp - 1) = sir->fifo_data & 0x00ff;
  364.             }
  365. #else
  366.             if ((sir->csr & SI_CSR_LOB) != 0) {
  367.             cp = sip->si_ma + (sip->si_cc - sir->bcr);
  368.             if ((sir->csr & SI_CSR_BPCON) == 0) {
  369.                 switch (sir->csr & SI_CSR_LOB) {
  370.                 case SI_CSR_LOB_THREE:
  371.                     *(cp - 3) = (sir->bpr & 0xff000000) >> 24;
  372.                     *(cp - 2) = (sir->bpr & 0x00ff0000) >> 16;
  373.                     *(cp - 1) = (sir->bpr & 0x0000ff00) >> 8;
  374.                     break;
  375.                 case SI_CSR_LOB_TWO:
  376.                     *(cp - 2) = (sir->bpr & 0xff000000) >> 24;
  377.                     *(cp - 1) = (sir->bpr & 0x00ff0000) >> 16;
  378.                     break;
  379.                 case SI_CSR_LOB_ONE:
  380.                     *(cp - 1) = (sir->bpr & 0xff000000) >> 24;
  381.                     break;
  382.                 }
  383.             } else {
  384.                 *(cp - 1) = (sir->bpr & 0x0000ff00) >> 8;
  385.             }
  386.             }
  387. #endif M25
  388.         }
  389.  
  390.         /* clear sbc interrupt */
  391.         junk = sir->sbc_rreg.clr;
  392.  
  393.         /* cleanup after a dma operation */
  394.         si_dma_cleanup(sir, ob);
  395.     }
  396.  
  397.     /* get status */
  398.     cp = (char *)scb;
  399.     for (i = 0;;) {
  400.         b = si_getbyte(sir, PHASE_STATUS);
  401.         if (b == -1) {
  402.             break;
  403.         }
  404.         if (i < STATUS_LEN) {
  405.             cp[i++] = b;
  406.         }
  407.     }
  408.     b = si_getbyte(sir, PHASE_MSG_IN);
  409.     if (b != SC_COMMAND_COMPLETE) {
  410.         if (b >= 0) {    /* if not, si_getbyte already printed msg */
  411.             sc_error("invalid message");
  412.         }
  413.         goto failed;
  414.     }
  415.     return (sip->si_cc - sir->bcr);
  416.  
  417. failed:
  418.     si_reset(sir, ob);
  419.     return (-1);
  420. }
  421.  
  422. #ifdef M25
  423. si_ob_dma_setup(sir, udct, cmd, cc, ma)
  424.     register struct scsi_si_reg *sir;
  425.     register struct udc_table *udct;
  426.     register u_char cmd;
  427.     register int cc;
  428.     register char *ma;
  429. {
  430.     /* setup udc dma info */
  431.     udct->haddr = ((SI_OB_DMA_ADDR(ma) & 0xff0000) >> 8) | 
  432.         UDC_ADDR_INFO;
  433.     udct->laddr = SI_OB_DMA_ADDR(ma) & 0xffff;
  434.     udct->hcmr = UDC_CMR_HIGH;
  435.     udct->count = cc / 2;
  436.     if ((cmd == SC_READ) || (cmd == SC_REQUEST_SENSE)) {
  437.         udct->rsel = UDC_RSEL_RECV;
  438.         udct->lcmr = UDC_CMR_LRECV;
  439.     } else {
  440.         udct->rsel = UDC_RSEL_SEND;
  441.         udct->lcmr = UDC_CMR_LSEND;
  442.         if (cc & 1) {
  443.             udct->count++;
  444.         }
  445.     }
  446.  
  447.     /* initialize chain address register */
  448.     DELAY(SI_UDC_WAIT);
  449.     sir->udc_raddr = UDC_ADR_CAR_HIGH;
  450.     DELAY(SI_UDC_WAIT);
  451.     sir->udc_rdata = ((int)udct & 0xff0000) >> 8;
  452.     DELAY(SI_UDC_WAIT);
  453.     sir->udc_raddr = UDC_ADR_CAR_LOW;
  454.     DELAY(SI_UDC_WAIT);
  455.     sir->udc_rdata = (int)udct & 0xffff;
  456.  
  457.     /* initialize master mode register */
  458.     DELAY(SI_UDC_WAIT);
  459.     sir->udc_raddr = UDC_ADR_MODE;
  460.     DELAY(SI_UDC_WAIT);
  461.     sir->udc_rdata = UDC_MODE;
  462.  
  463.     /* issue start chain command */
  464.     DELAY(SI_UDC_WAIT);
  465.     sir->udc_raddr = UDC_ADR_COMMAND;
  466.     DELAY(SI_UDC_WAIT);
  467.     sir->udc_rdata = UDC_CMD_STRT_CHN;
  468. }
  469. #endif M25
  470.  
  471. /*
  472.  * Reset some register information after a dma operation.
  473.  */
  474. si_dma_cleanup(sir, ob)
  475.     register struct scsi_si_reg *sir;
  476.     register int ob;
  477. {
  478. #ifdef M25
  479.     sir->udc_raddr = UDC_ADR_COMMAND;
  480.     DELAY(SI_UDC_WAIT);
  481.     sir->udc_rdata = UDC_CMD_RESET;
  482. #else
  483.     sir->csr &- ~SI_CSR_DMA_EN;
  484.     sir->dma_addr = 0;
  485. #endif M25
  486.     sir->sbc_wreg.mr &= ~SBC_MR_DMA;
  487.     sir->sbc_wreg.icr = 0;
  488.     sir->sbc_wreg.tcr = 0;
  489. }
  490.  
  491. /*
  492.  * Wait for a condition to be (de)asserted.
  493.  */
  494. si_wait(reg, cond, set)
  495.     register u_short *reg;
  496.     register u_short cond;
  497.     register int set;
  498. {
  499.     register int i;
  500.     register u_short regval;
  501.  
  502.     for (i = 0; i < 3000; i++) {
  503.         regval = *reg;
  504.         if ((set == 1) && (regval & cond)) {
  505.             return (1);
  506.         }
  507.         if ((set == 0) && !(regval & cond)) {
  508.             return (1);
  509.         } 
  510.         DELAY(5000);
  511.     }
  512.     return (0);
  513. }
  514.  
  515. /*
  516.  * Wait for a condition to be (de)asserted on the scsi bus.
  517.  */
  518. si_sbc_wait(reg, cond, set)
  519.     register caddr_t reg;
  520.     register u_char cond;
  521.     register int set;
  522. {
  523.     register int i;
  524.     register u_char regval;
  525.  
  526.     for (i = 0; i < 1000; i++) {
  527.         regval = *reg;
  528.         if ((set == 1) && (regval & cond)) {
  529.             return (1);
  530.         }
  531.         if ((set == 0) && !(regval & cond)) {
  532.             return (1);
  533.         } 
  534.         DELAY(5000);
  535.     }
  536.     return (0);
  537. }
  538.  
  539. /*
  540.  * Put a byte onto the scsi bus.
  541.  */
  542. si_putbyte(sir, phase, data, numbytes)
  543.     register struct scsi_si_reg *sir;
  544.     register u_short phase;
  545.     register u_char *data;
  546.     register int numbytes;
  547. {
  548.     register int i;
  549.  
  550.     /* set up tcr so a phase match will occur */
  551.     if (phase == PHASE_COMMAND) {
  552.         sir->sbc_wreg.tcr = TCR_COMMAND;
  553.     } else if (phase == PHASE_MSG_OUT) {
  554.         sir->sbc_wreg.tcr = TCR_MSG_OUT;
  555.     } else {
  556.         sc_error("putbyte, bad phase specified");
  557.         return (0);
  558.     }
  559.  
  560.     /* put all desired bytes onto scsi bus */
  561.     for (i = 0; i < numbytes; i++) {
  562.         /* wait for target to request a byte */
  563.         if (si_sbc_wait(&sir->sbc_rreg.cbsr, SBC_CBSR_REQ, 1) == 0) {
  564.             sc_error("putbyte: target never set REQ");
  565.             return (0);
  566.         }
  567.  
  568.         /* load data for transfer */
  569.         sir->sbc_wreg.odr = *data++;
  570.         sir->sbc_wreg.icr = SBC_ICR_DATA;
  571.  
  572.         /* make sure phase match occurred */
  573.         if ((sir->sbc_rreg.bsr & SBC_BSR_PMTCH) == 0) {
  574.             sc_error("putbyte: phase mismatch");
  575.             return (0);
  576.         }
  577.  
  578.         /* complete req/ack handshake */
  579.         sir->sbc_wreg.icr |= SBC_ICR_ACK;
  580.         if (si_sbc_wait(&sir->sbc_rreg.cbsr, SBC_CBSR_REQ, 0) == 0) {
  581.             sc_error("putbyte: target never released REQ");
  582.             return (0);
  583.         }
  584.         sir->sbc_wreg.icr = 0;
  585.     }
  586.     sir->sbc_wreg.tcr = 0;
  587.     return (1);
  588. }
  589.  
  590. /*
  591.  * Get a byte from the scsi bus.
  592.  */
  593. si_getbyte(sir, phase)
  594.     register struct scsi_si_reg *sir;
  595.     register u_short phase;
  596. {
  597.     register u_char data;
  598.     register int i;
  599.  
  600.     /* set up tcr so a phase match will occur */
  601.     if (phase == PHASE_STATUS) {
  602.         sir->sbc_wreg.tcr = TCR_STATUS;
  603.     } else if (phase == PHASE_MSG_IN) {
  604.         sir->sbc_wreg.tcr = TCR_MSG_IN;
  605.     } else {
  606.         sc_error("getbyte, bad phase specified");
  607.         return (-1);
  608.     }
  609.  
  610.     /* wait for target request */
  611.     for (i=0; i < 20; i++) {
  612.         if (si_sbc_wait(&sir->sbc_rreg.cbsr, SBC_CBSR_REQ, 1)) {
  613.             break;
  614.         }
  615.     }
  616.     if (si_sbc_wait(&sir->sbc_rreg.cbsr, SBC_CBSR_REQ, 1) == 0) {
  617.         sc_error("getbyte: target never set REQ");
  618.         sir->sbc_wreg.tcr = 0;
  619.         return (-1);
  620.     }
  621.  
  622.     /* check for correct information phase on scsi bus */
  623.     if (phase != (sir->sbc_rreg.cbsr & CBSR_PHASE_BITS)) {
  624.         if (phase != PHASE_STATUS) {
  625.             sc_error("getbyte: phase mismatch");
  626.         }
  627.         sir->sbc_wreg.tcr = 0;
  628.         return (-1);
  629.     }
  630.  
  631.     /* grab data */
  632.     data = sir->sbc_rreg.cdr;
  633.     sir->sbc_wreg.icr = SBC_ICR_ACK;
  634.  
  635.     /* complete req/ack handshake */
  636.     if (si_sbc_wait(&sir->sbc_rreg.cbsr, SBC_CBSR_REQ, 0) == 0) {
  637.         sc_error("getbyte: target never released REQ");
  638.         sir->sbc_wreg.icr = 0;
  639.         sir->sbc_wreg.tcr = 0;
  640.         return (-1);
  641.     }
  642.     sir->sbc_wreg.icr = 0;
  643.     sir->sbc_wreg.tcr = 0;
  644.     return (data);
  645. }
  646.  
  647. /*
  648.  * Reset SCSI control logic.
  649.  */
  650. si_reset(sir, ob)
  651.     register struct scsi_si_reg *sir;
  652.     register int ob;
  653. {
  654.     register u_char junk;
  655.  
  656.     /* reset bcr, fifo, udc, and sbc */
  657.     sir->bcr = 0;
  658.     sir->csr = 0;
  659.     DELAY(10);
  660.     sir->csr = SI_CSR_SCSI_RES|SI_CSR_FIFO_RES;
  661. #ifndef M25
  662.     sir->dma_addr = 0;
  663.     sir->dma_count = 0;
  664. #endif M25
  665.  
  666.     /* issue scsi bus reset */
  667.     sir->sbc_wreg.icr = SBC_ICR_RST;
  668.     DELAY(50);
  669.     sir->sbc_wreg.icr = 0;
  670.     junk = sir->sbc_rreg.clr;
  671.     DELAY(10000000);
  672. }
  673. #endif SUN3
  674.